/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.catalina.ha.deploy;

import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.tomcat.util.res.StringManager;

import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * <p>
 * The <b>WarWatcher </b> watches the deployDir for changes made to the
 * directory (adding new WAR files->deploy or remove WAR files->undeploy) And
 * notifies a listener of the changes made
 * </p>
 *
 * @author Filip Hanik
 * @author Peter Rossbach
 * @version 1.1
 */

public class WarWatcher {

	/*--Static Variables----------------------------------------*/
	private static final Log log = LogFactory.getLog(WarWatcher.class);
	private static final StringManager sm =
			StringManager.getManager(Constants.Package);

    /*--Instance Variables--------------------------------------*/
	/**
	 * Directory to watch for war files
	 */
	protected File watchDir = null;

	/**
	 * Parent to be notified of changes
	 */
	protected FileChangeListener listener = null;

	/**
	 * Currently deployed files
	 */
	protected Map<String, WarInfo> currentStatus =
			new HashMap<String, WarInfo>();

    /*--Constructor---------------------------------------------*/

	public WarWatcher() {
	}

	public WarWatcher(FileChangeListener listener, File watchDir) {
		this.listener = listener;
		this.watchDir = watchDir;
	}

    /*--Logic---------------------------------------------------*/

	/**
	 * check for modification and send notification to listener
	 */
	public void check() {
		if (log.isDebugEnabled())
			log.debug(sm.getString("warWatcher.checkingWars", watchDir));
		File[] list = watchDir.listFiles(new WarFilter());
		if (list == null) {
			log.warn(sm.getString("warWatcher.cantListWatchDir",
					watchDir));

			list = new File[0];
		}
		//first make sure all the files are listed in our current status
		for (int i = 0; i < list.length; i++) {
			if (!list[i].exists())
				log.warn(sm.getString("warWatcher.listedFileDoesNotExist",
						list[i], watchDir));

			addWarInfo(list[i]);
		}

		// Check all the status codes and update the FarmDeployer
		for (Iterator<Map.Entry<String, WarInfo>> i =
		     currentStatus.entrySet().iterator(); i.hasNext(); ) {
			Map.Entry<String, WarInfo> entry = i.next();
			WarInfo info = entry.getValue();
			if (log.isTraceEnabled())
				log.trace(sm.getString("warWatcher.checkingWar",
						info.getWar()));
			int check = info.check();
			if (check == 1) {
				listener.fileModified(info.getWar());
			} else if (check == -1) {
				listener.fileRemoved(info.getWar());
				//no need to keep in memory
				i.remove();
			}
			if (log.isTraceEnabled())
				log.trace(sm.getString("warWatcher.checkWarResult",
						Integer.valueOf(check),
						info.getWar()));
		}

	}

	/**
	 * add cluster war to the watcher state
	 *
	 * @param warfile
	 */
	protected void addWarInfo(File warfile) {
		WarInfo info = currentStatus.get(warfile.getAbsolutePath());
		if (info == null) {
			info = new WarInfo(warfile);
			info.setLastState(-1); //assume file is non existent
			currentStatus.put(warfile.getAbsolutePath(), info);
		}
	}

	/**
	 * clear watcher state
	 */
	public void clear() {
		currentStatus.clear();
	}

	/**
	 * @return Returns the watchDir.
	 */
	public File getWatchDir() {
		return watchDir;
	}

	/**
	 * @param watchDir The watchDir to set.
	 */
	public void setWatchDir(File watchDir) {
		this.watchDir = watchDir;
	}

	/**
	 * @return Returns the listener.
	 */
	public FileChangeListener getListener() {
		return listener;
	}

	/**
	 * @param listener The listener to set.
	 */
	public void setListener(FileChangeListener listener) {
		this.listener = listener;
	}

    /*--Inner classes-------------------------------------------*/

	/**
	 * File name filter for war files
	 */
	protected static class WarFilter implements java.io.FilenameFilter {
		@Override
		public boolean accept(File path, String name) {
			if (name == null)
				return false;
			return name.endsWith(".war");
		}
	}

	/**
	 * File information on existing WAR files
	 */
	protected static class WarInfo {
		protected File war = null;

		protected long lastChecked = 0;

		protected long lastState = 0;

		public WarInfo(File war) {
			this.war = war;
			this.lastChecked = war.lastModified();
			if (!war.exists())
				lastState = -1;
		}

		public boolean modified() {
			return war.exists() && war.lastModified() > lastChecked;
		}

		public boolean exists() {
			return war.exists();
		}

		/**
		 * Returns 1 if the file has been added/modified, 0 if the file is
		 * unchanged and -1 if the file has been removed
		 *
		 * @return int 1=file added; 0=unchanged; -1=file removed
		 */
		public int check() {
			//file unchanged by default
			int result = 0;

			if (modified()) {
				//file has changed - timestamp
				result = 1;
				lastState = result;
			} else if ((!exists()) && (!(lastState == -1))) {
				//file was removed
				result = -1;
				lastState = result;
			} else if ((lastState == -1) && exists()) {
				//file was added
				result = 1;
				lastState = result;
			}
			this.lastChecked = System.currentTimeMillis();
			return result;
		}

		public File getWar() {
			return war;
		}

		@Override
		public int hashCode() {
			return war.getAbsolutePath().hashCode();
		}

		@Override
		public boolean equals(Object other) {
			if (other instanceof WarInfo) {
				WarInfo wo = (WarInfo) other;
				return wo.getWar().equals(getWar());
			} else {
				return false;
			}
		}

		protected void setLastState(int lastState) {
			this.lastState = lastState;
		}

	}

}